home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 050 / madtrb1.arc / G_I_TPL.GEN < prev    next >
Text File  |  1986-03-27  |  12KB  |  272 lines
  1. { G_I_TPL.GEN }
  2.  
  3. { *************************************************************************** }
  4. { *                                                                         * }
  5. { *                TURBO SCREEN INPUT PRE-PROCESSOR TOOLKIT                 * }
  6. { *                                                                         * }
  7. { *                GENERAL INPUT SCREEN TEMPLATE GENERATOR                  * }
  8. { *                                                                         * }
  9. { *                             Version  1.07                               * }
  10. { *                                                                         * }
  11. { *                                                                         * }
  12. { *   This template generator provides a method of inputing the input       * }
  13. { *   prompt parameters for the general input page template used in the     * }
  14. { *   general input pages for the pre-processor storing them in a template  * }
  15. { *   file so that they can be read and used by the general input page      * }
  16. { *   subprogram.                                                           * }
  17. { *                                                                         * }
  18. { *************************************************************************** }
  19.  
  20.  
  21.  
  22. Procedure FileGeneratorModule;
  23.  
  24. { *************************************************************************** }
  25. { *                                                                         * }
  26. { *                    SCREEN TEMPLATE GENERATOR MODULE                     * }
  27. { *                                                                         * }
  28. { *  This module reads the record entries out of a file, places the entries * }
  29. { *  in an array, allows you to inspect the entries and change them if so   * }
  30. { *  desired, and then writes the record entries back to the file.          * }
  31. { *                                                                         * }
  32. { *  This screen template generator is used to generate a template which    * }
  33. { *  stores the following information about each entry in its record:       * }
  34. { *                                                                         * }
  35. { *        PromptCol        ( column location of input prompt on screen )   * }
  36. { *        PromptRow        ( row location of input prompt on screen )      * }
  37. { *        InputCol         ( column location of input data entry field )   * }
  38. { *        InputRow         ( row location of input data entry field )      * }
  39. { *        InputLength      ( maximum length of input data entry )          * }
  40. { *        InputDataType:                                                   * }
  41. { *                                                                         * }
  42. { *             1 = Positive Integer                                        * }
  43. { *             2 = Negative Integer                                        * }
  44. { *             3 = Integer                                                 * }
  45. { *             4 = Positive Real                                           * }
  46. { *             5 = Negative Real                                           * }
  47. { *             6 = Real                                                    * }
  48. { *             7 = File Name Characters                                    * }
  49. { *             8 = Disk Drive Subdirectory Path Characters                 * }
  50. { *             9 = General Characters                                      * }
  51. { *                                                                         * }
  52. { *        ReturnKeyPointer ( pointer to corresponding record for a         * }
  53. { *                           carriage return entry )                       * }
  54. { *        UpKeyPointer     ( pointer to corresponding record for a up      * }
  55. { *                           key entry )                                   * }
  56. { *        DownKeyPointer   ( pointer to corresponding record for a down    * }
  57. { *                           key entry )                                   * }
  58. { *        LeftKeyPointer   ( pointer to corresponding record for a left    * }
  59. { *                           key entry )                                   * }
  60. { *        RightKeyPointer  ( pointer to corresponding record for a right   * }
  61. { *                           key entry )                                   * }
  62. { *                                                                         * }
  63. { *************************************************************************** }
  64.  
  65. {$V-}
  66.  
  67. Const
  68.  
  69.   TEMPLATE_RECORD_LIMIT=26;            { number of records used in the template }
  70.  
  71.   TEMPLATE_FILE_NAME='G_I_01.TPL';     { name of template file being generated }
  72.  
  73.   MAX_SIZE_OF_G_I_PROMPT=50;           { size of general input prompt string }
  74.  
  75.  
  76.  
  77. Type
  78.  
  79.   TemplateRecord=                      { record type used for general input page templates, used to store }
  80.     Record                             { specific information about a particular general input page prompt }
  81.       PromptCol:Integer;
  82.       PromptRow:Integer;
  83.       InputCol:Integer;
  84.       InputRow:Integer;
  85.       InputLength:Integer;
  86.       InputDataType:Integer;
  87.       ReturnKeyPointer:Integer;
  88.       UpKeyPointer:Integer;
  89.       DownKeyPointer:Integer;
  90.       LeftKeyPointer:Integer;
  91.       RightKeyPointer:Integer;
  92.       Prompt:String[MAX_SIZE_OF_G_I_PROMPT];
  93.     End; { TemplateRecord }
  94.  
  95.  
  96.  
  97. Var
  98.  
  99.   Template:Array[1..TEMPLATE_RECORD_LIMIT] of TemplateRecord; { an array used to store the template }
  100.  
  101.   TemplateFile:File Of TemplateRecord;                        { a file type used to store templates }
  102.  
  103.   RecordNumber:Integer;                                       { a index to the current template record being updated }
  104.  
  105.   RecordOK:Char;                                              { a character variable read from the keyboard }
  106.  
  107.  
  108.  
  109.   Procedure InitializeTemplateEntries;
  110.  
  111.   { This procedure initializes the entries in the template array of records.
  112.     This procedure removes any garbage that might have been in the memory
  113.     locations that the template array now uses. }
  114.  
  115.   Var
  116.     RecordNumber:Integer;              { a index counter to a template record }
  117.  
  118.   Begin   { InitializeTemplateEntries }
  119.     For RecordNumber:=1 To TEMPLATE_RECORD_LIMIT Do
  120.       With Template[RecordNumber] Do
  121.         Begin
  122.           PromptCol:=0;
  123.           PromptRow:=0;
  124.           InputCol:=0;
  125.           InputRow:=0;
  126.           InputLength:=0;
  127.           InputDataType:=0;
  128.           ReturnKeyPointer:=0;
  129.           UpKeyPointer:=0;
  130.           DownKeyPointer:=0;
  131.           LeftKeyPointer:=0;
  132.           RightKeyPointer:=0;
  133.           Prompt:='';
  134.         End;  { With Template }
  135.   End;    { InitializeTemplateEntries }
  136.  
  137.  
  138.  
  139.   Procedure ReadFileEntries;
  140.  
  141.   { This procedure reads the entries out of the template file named above and
  142.     stores the entries into the proper template array record. }
  143.  
  144.   Var
  145.     RecordNumber:Integer;              { a index counter to a template record }
  146.  
  147.   Begin   { ReadFileEntries }
  148.     RecordNumber:=1;                   { initialize record number counter }
  149.     {$I-}                              { enable error trapping }
  150.     Assign(TemplateFile,TEMPLATE_FILE_NAME);     { assign to a disk file }
  151.     Reset(TemplateFile);                         { open the file for reading }
  152.     If IOResult=0 Then                           { if file exists then start reading of file }
  153.       Repeat
  154.         Read(TemplateFile,Template[RecordNumber]); { read record off of disk }
  155.         RecordNumber:=RecordNumber+1;            { increment record number counter }
  156.       Until (IOResult<>0) Or (RecordNumber=TEMPLATE_RECORD_LIMIT+1); { read until end of file or template record limit }
  157.     Close(TemplateFile);               { close the template file }
  158.     {$I+}                              { disable error trapping }
  159.   End;    { ReadFileEntries }
  160.  
  161.  
  162.  
  163.   Procedure WriteFileEntries;
  164.  
  165.   { This procedure takes the entrys stored in the template array records and
  166.     writes them to the template file named above. }
  167.  
  168.   Var
  169.     RecordNumber:Integer;              { a index counter to a template record }
  170.  
  171.   Begin   { WriteFileEntries }
  172.     Assign(TemplateFile,TEMPLATE_FILE_NAME);      { assign to a file on disk }
  173.     Rewrite(TemplateFile);                        { open the file for writing, removes any previous entries }
  174.     For RecordNumber:=1 To TEMPLATE_RECORD_LIMIT Do
  175.       Write(TemplateFile,Template[RecordNumber]); { put the next record out }
  176.     Close(TemplateFile);
  177.   End;    { WriteFileEntries }
  178.  
  179.  
  180.  
  181.   Procedure ShowTemplateRecord;
  182.  
  183.   { This procedure shows the operator the template entries in the template array
  184.     for the current record number. }
  185.  
  186.   Begin   { ShowTemplateRecord }
  187.     With Template[RecordNumber] Do
  188.       Begin
  189.         WriteLn('Record Number=    ',RecordNumber);
  190.         WriteLn;
  191.         WriteLn('PromptCol=        ',PromptCol);
  192.         WriteLn('PromptRow=        ',PromptRow);
  193.         WriteLn('InputCol=         ',InputCol);
  194.         WriteLn('InputRow=         ',InputRow);
  195.         WriteLn('InputLength=      ',InputLength);
  196.         WriteLn('InputDataType=    ',InputDataType);
  197.         WriteLn('ReturnKeyPointer= ',ReturnKeyPointer);
  198.         WriteLn('UpKeyPointer=     ',UpKeyPointer);
  199.         WriteLn('DownKeyPointer=   ',DownKeyPointer);
  200.         WriteLn('LeftKeyPointer=   ',LeftKeyPointer);
  201.         WriteLn('RightKeyPointer=  ',RightKeyPointer);
  202.         WriteLn('Prompt=           ',Prompt);
  203.       End; { With Template[RecordNumber] }
  204.   End;    { ShowTemplateRecord }
  205.  
  206.  
  207.  
  208.   Procedure EnterTemplateRecord;
  209.  
  210.   { This procedure reads the template entries from the user and places them
  211.     into the current template record. }
  212.  
  213.   Begin   { EnterTemplateRecord }
  214.     With Template[RecordNumber] Do
  215.       Begin
  216.         WriteLn('Record Number=',RecordNumber);
  217.         WriteLn;
  218.         Write('PromptCol=        ?');
  219.           ReadLn(PromptCol);
  220.         Write('PromptRow=        ?');
  221.           ReadLn(PromptRow);
  222.         Write('InputCol=         ?');
  223.           ReadLn(InputCol);
  224.         Write('InputRow=         ?');
  225.           ReadLn(InputRow);
  226.         Write('InputLength=      ?');
  227.           ReadLn(InputLength);
  228.         Write('InputDataType=    ?');
  229.           ReadLn(InputDataType);
  230.         Write('ReturnKeyPointer= ?');
  231.           ReadLn(ReturnKeyPointer);
  232.         Write('UpKeyPointer=     ?');
  233.           ReadLn(UpKeyPointer);
  234.         Write('DownKeyPointer=   ?');
  235.           ReadLn(DownKeyPointer);
  236.         Write('LeftKeyPointer=   ?');
  237.           ReadLn(LeftKeyPointer);
  238.         Write('RightKeyPointer=  ?');
  239.           ReadLn(RightKeyPointer);
  240.         Write('Prompt=           ?');
  241.           ReadLn(Prompt);
  242.       End;   { With Template[RecordNumber] }
  243.   End;    { EnterTemplateRecord }
  244.  
  245.  
  246.  
  247. Begin     { FileGeneratorModule }
  248.   RecordNumber:=1;                     { initialize the record index }
  249.   InitializeTemplateEntries;
  250.   ReadFileEntries;
  251.   Repeat
  252.     ClrScr;
  253.     ShowTemplateRecord;
  254.     WriteLn;
  255.     Write('Are the above entries correct (Y or N) ?');
  256.     ReadLn(RecordOK);
  257.     If (RecordOK<>'Y') And (RecordOK<>'y') Then
  258.       Begin
  259.         ClrScr;
  260.         EnterTemplateRecord;
  261.       End { If (RecordOK<> }
  262.     Else { increment record index }
  263.       RecordNumber:=RecordNumber+1;
  264.   Until RecordNumber=TEMPLATE_RECORD_LIMIT+1;
  265.   WriteFileEntries;
  266. End;      { FileGeneratorModule }
  267.  
  268.  
  269.  
  270. Begin   { Main Program }
  271.   FileGeneratorModule;
  272. End.    { Main Program }